package com.ourteam.product.requirement.dao;

import net.dao.BaseQueryBean;
import net.dao.BaseWhereCriterion;
import net.dao.IDataAccessInterface;

import org.apache.commons.lang.StringUtils;

import java.util.Arrays;
import java.util.List;
import java.util.Map;


/**
 * Template Name : DAO查询对象
 * Template Version : 1
 * Template Last Modfiy Date : Sat Aug 19 10:06:32 CST 2017
 * Auto Generate Date : 2018-05-03 16:45:31
  * Warning ! This file will be overwrite when regenerate !
  *
 */
public class ProductVersionStageDAOQueryBean extends BaseQueryBean {
    public ProductVersionStageDAOQueryBean() {
        super();
    }

    public ProductVersionStageDAOQueryBean(BaseQueryBean aQueryBean) {
        super(aQueryBean);
    }

    public ProductVersionStageDAOQueryBean(BaseQueryBean aQueryBean,
        Map tableReplaceMap) {
        super(aQueryBean, tableReplaceMap);
    }

    public Criteria createCriteria() {
        Criteria criteria = createCriteriaInternal();

        if (oredCriteria.size() == 0) {
            oredCriteria.add(criteria);
        }

        return criteria;
    }

    protected Criteria createCriteriaInternal() {
        return new Criteria(this);
    }

    public void addIdSelectProperty() {
        addIdSelectProperty("id");
    }

    public void addIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.Id, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.Id, "id");
        }
    }

    public void addProductVersionIdSelectProperty() {
        addProductVersionIdSelectProperty("productVersionId");
    }

    public void addProductVersionIdSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.ProductVersionId, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.ProductVersionId,
                "productVersionId");
        }
    }

    public void addStageNameSelectProperty() {
        addStageNameSelectProperty("stageName");
    }

    public void addStageNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.StageName, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.StageName, "stageName");
        }
    }

    public void addStartDateSelectProperty() {
        addStartDateSelectProperty("startDate");
    }

    public void addStartDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.StartDate, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.StartDate, "startDate");
        }
    }

    public void addEndDateSelectProperty() {
        addEndDateSelectProperty("endDate");
    }

    public void addEndDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.EndDate, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.EndDate, "endDate");
        }
    }

    public void addActualStartDateSelectProperty() {
        addActualStartDateSelectProperty("actualStartDate");
    }

    public void addActualStartDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.ActualStartDate, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.ActualStartDate,
                "actualStartDate");
        }
    }

    public void addActualEndDateSelectProperty() {
        addActualEndDateSelectProperty("actualEndDate");
    }

    public void addActualEndDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.ActualEndDate, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.ActualEndDate,
                "actualEndDate");
        }
    }

    public void addSortIndexSelectProperty() {
        addSortIndexSelectProperty("sortIndex");
    }

    public void addSortIndexSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.SortIndex, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.SortIndex, "sortIndex");
        }
    }

    public void addStatusSelectProperty() {
        addStatusSelectProperty("status");
    }

    public void addStatusSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.Status, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.Status, "status");
        }
    }

    public void addRemarksSelectProperty() {
        addRemarksSelectProperty("remarks");
    }

    public void addRemarksSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.Remarks, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.Remarks, "remarks");
        }
    }

    public void addProductVersionNameSelectProperty() {
        addProductVersionNameSelectProperty("productVersionName");
    }

    public void addProductVersionNameSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.ProductVersionName, aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.ProductVersionName,
                "productVersionName");
        }
    }

    public void addProductVersionStartDateSelectProperty() {
        addProductVersionStartDateSelectProperty("productVersionStartDate");
    }

    public void addProductVersionStartDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.ProductVersionStartDate,
                aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.ProductVersionStartDate,
                "productVersionStartDate");
        }
    }

    public void addProductVersionEndDateSelectProperty() {
        addProductVersionEndDateSelectProperty("productVersionEndDate");
    }

    public void addProductVersionEndDateSelectProperty(String aAlias) {
        if (StringUtils.isNotBlank(aAlias)) {
            addSelectProperty(IProductVersionStageDAO.ProductVersionEndDate,
                aAlias);
        } else {
            addSelectProperty(IProductVersionStageDAO.ProductVersionEndDate,
                "productVersionEndDate");
        }
    }

    public void addAllSelectProperties() {
        addIdSelectProperty();

        addProductVersionIdSelectProperty();

        addStageNameSelectProperty();

        addStartDateSelectProperty();

        addEndDateSelectProperty();

        addActualStartDateSelectProperty();

        addActualEndDateSelectProperty();

        addSortIndexSelectProperty();

        addStatusSelectProperty();

        addRemarksSelectProperty();

        addProductVersionNameSelectProperty();

        addProductVersionStartDateSelectProperty();

        addProductVersionEndDateSelectProperty();
    }

    public static class Criteria extends BaseWhereCriterion<ProductVersionStageDAOQueryBean> {
        protected Criteria(ProductVersionStageDAOQueryBean aParentObject) {
            super(aParentObject);
        }

        public Criteria andIdIsNull() {
            addCriterion(IProductVersionStageDAO.Id + " is null");

            return this;
        }

        public Criteria andIdIsNotNull() {
            addCriterion(IProductVersionStageDAO.Id + " is not null");

            return this;
        }

        public Criteria andIdIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.Id + " is not null AND " +
                IProductVersionStageDAO.Id + " <> ''");

            return this;
        }

        public Criteria andIdIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.Id + " is null OR " +
                IProductVersionStageDAO.Id + " = '')");

            return this;
        }

        public Criteria andIdEqualTo(long value) {
            return andIdEqualTo(Long.valueOf(value));
        }

        public Criteria andIdEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " = ", value, "id");

            return this;
        }

        public Criteria andIdEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Id);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotEqualTo(long value) {
            return andIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToOrIsNull(long value) {
            return andIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andIdNotEqualToOrIsNull(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " is null OR " +
                IProductVersionStageDAO.Id + " <>", value, "id");

            return this;
        }

        public Criteria andIdNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Id);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThan(long value) {
            return andIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " >", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Id);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(long value) {
            return andIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdGreaterThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " >=", value, "id");

            return this;
        }

        public Criteria andIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Id);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdGreaterThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThan(long value) {
            return andIdLessThan(Long.valueOf(value));
        }

        public Criteria andIdLessThan(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " <", value, "id");

            return this;
        }

        public Criteria andIdLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Id);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(long value) {
            return andIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andIdLessThanOrEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.Id + " <=", value, "id");

            return this;
        }

        public Criteria andIdLessThanOrEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Id);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andIdLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdIn(long[] values) {
            if (values.length == 1) {
                return andIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Id + " not in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.Id + " in", values, "id");

                return this;
            }
        }

        public Criteria andIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.Id + " not in", values,
                    "id");

                return this;
            }
        }

        public Criteria andIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Id + " in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Id + " not in",
                    Arrays.asList(values), "id");

                return this;
            }
        }

        public Criteria andIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Id + " not in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andIdBetween(long value1, long value2) {
            addCriterion(IProductVersionStageDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionStageDAO.Id + " between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(long value1, long value2) {
            addCriterion(IProductVersionStageDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionStageDAO.Id + " not between", value1,
                value2, "id");

            return this;
        }

        public Criteria andProductVersionIdIsNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " is null");

            return this;
        }

        public Criteria andProductVersionIdIsNotNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionId +
                " is not null");

            return this;
        }

        public Criteria andProductVersionIdIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.ProductVersionId +
                " is not null AND " + IProductVersionStageDAO.ProductVersionId +
                " <> ''");

            return this;
        }

        public Criteria andProductVersionIdIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.ProductVersionId +
                " is null OR " + IProductVersionStageDAO.ProductVersionId +
                " = '')");

            return this;
        }

        public Criteria andProductVersionIdEqualTo(long value) {
            return andProductVersionIdEqualTo(Long.valueOf(value));
        }

        public Criteria andProductVersionIdEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " = ",
                value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionId);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionIdEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdNotEqualTo(long value) {
            return andProductVersionIdNotEqualTo(Long.valueOf(value));
        }

        public Criteria andProductVersionIdNotEqualTo(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " <>",
                value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdNotEqualToOrIsNull(long value) {
            return andProductVersionIdNotEqualToOrIsNull(Long.valueOf(value));
        }

        public Criteria andProductVersionIdNotEqualToOrIsNull(
            java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId +
                " is null OR " + IProductVersionStageDAO.ProductVersionId +
                " <>", value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionId);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionIdNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdGreaterThan(long value) {
            return andProductVersionIdGreaterThan(Long.valueOf(value));
        }

        public Criteria andProductVersionIdGreaterThan(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " >",
                value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionId);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionIdGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdGreaterThanOrEqualTo(long value) {
            return andProductVersionIdGreaterThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductVersionIdGreaterThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " >=",
                value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionId);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionIdGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdLessThan(long value) {
            return andProductVersionIdLessThan(Long.valueOf(value));
        }

        public Criteria andProductVersionIdLessThan(java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " <",
                value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionId);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionIdLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdLessThanOrEqualTo(long value) {
            return andProductVersionIdLessThanOrEqualTo(Long.valueOf(value));
        }

        public Criteria andProductVersionIdLessThanOrEqualTo(
            java.lang.Long value) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " <=",
                value, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionId);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionIdLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdIn(long[] values) {
            if (values.length == 1) {
                return andProductVersionIdEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionId + " in",
                    values, "productVersionId");

                return this;
            }
        }

        public Criteria andProductVersionIdNotIn(long[] values) {
            if (values.length == 1) {
                return andProductVersionIdNotEqualTo((java.lang.Long) values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionId +
                    " not in", values, "productVersionId");

                return this;
            }
        }

        public Criteria andProductVersionIdIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductVersionIdEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionId + " in",
                    values, "productVersionId");

                return this;
            }
        }

        public Criteria andProductVersionIdNotIn(List<java.lang.Long> values) {
            if (values.size() == 1) {
                return andProductVersionIdNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionId +
                    " not in", values, "productVersionId");

                return this;
            }
        }

        public Criteria andProductVersionIdIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductVersionIdEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionId + " in",
                    Arrays.asList(values), "productVersionId");

                return this;
            }
        }

        public Criteria andProductVersionIdNotIn(java.lang.Long[] values) {
            if (values.length == 1) {
                return andProductVersionIdNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionId +
                    " not in", Arrays.asList(values), "productVersionId");

                return this;
            }
        }

        public Criteria andProductVersionIdIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionIdBetween(long value1, long value2) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " between",
                value1, value2, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionStageDAO.ProductVersionId + " between",
                value1, value2, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdNotBetween(long value1, long value2) {
            addCriterion(IProductVersionStageDAO.ProductVersionId +
                " not between", value1, value2, "productVersionId");

            return this;
        }

        public Criteria andProductVersionIdNotBetween(java.lang.Long value1,
            java.lang.Long value2) {
            addCriterion(IProductVersionStageDAO.ProductVersionId +
                " not between", value1, value2, "productVersionId");

            return this;
        }

        public Criteria andStageNameIsNull() {
            addCriterion(IProductVersionStageDAO.StageName + " is null");

            return this;
        }

        public Criteria andStageNameIsNotNull() {
            addCriterion(IProductVersionStageDAO.StageName + " is not null");

            return this;
        }

        public Criteria andStageNameIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.StageName +
                " is not null AND " + IProductVersionStageDAO.StageName +
                " <> ''");

            return this;
        }

        public Criteria andStageNameIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.StageName +
                " is null OR " + IProductVersionStageDAO.StageName + " = '')");

            return this;
        }

        public Criteria andStageNameEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " = ", value,
                "stageName");

            return this;
        }

        public Criteria andStageNameEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StageName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStageNameEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameNotEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " <>", value,
                "stageName");

            return this;
        }

        public Criteria andStageNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " is null OR " +
                IProductVersionStageDAO.StageName + " <>", value, "stageName");

            return this;
        }

        public Criteria andStageNameNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StageName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStageNameNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameGreaterThan(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " >", value,
                "stageName");

            return this;
        }

        public Criteria andStageNameGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StageName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStageNameGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " >=", value,
                "stageName");

            return this;
        }

        public Criteria andStageNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StageName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStageNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameLessThan(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " <", value,
                "stageName");

            return this;
        }

        public Criteria andStageNameLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StageName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStageNameLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.StageName + " <=", value,
                "stageName");

            return this;
        }

        public Criteria andStageNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StageName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStageNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.StageName + " like",
                buffer.toString(), "stageName");

            return this;
        }

        public Criteria andStageNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.StageName + " not like",
                buffer.toString(), "stageName");

            return this;
        }

        public Criteria andStageNameIn(List<String> values) {
            if (values.size() == 1) {
                return andStageNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.StageName + " in", values,
                    "stageName");

                return this;
            }
        }

        public Criteria andStageNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStageNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.StageName + " not in",
                    values, "stageName");

                return this;
            }
        }

        public Criteria andStageNameIn(String[] values) {
            if (values.length == 1) {
                return andStageNameEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.StageName + " in",
                    Arrays.asList(values), "stageName");

                return this;
            }
        }

        public Criteria andStageNameNotIn(String[] values) {
            if (values.length == 1) {
                return andStageNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.StageName + " not in",
                    Arrays.asList(values), "stageName");

                return this;
            }
        }

        public Criteria andStageNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StageName + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStageNameBetween(String value1, String value2) {
            addCriterion(IProductVersionStageDAO.StageName + " between",
                value1, value2, "stageName");

            return this;
        }

        public Criteria andStageNameNotBetween(String value1, String value2) {
            addCriterion(IProductVersionStageDAO.StageName + " not between",
                value1, value2, "stageName");

            return this;
        }

        public Criteria andStartDateIsNull() {
            addCriterion(IProductVersionStageDAO.StartDate + " is null");

            return this;
        }

        public Criteria andStartDateIsNotNull() {
            addCriterion(IProductVersionStageDAO.StartDate + " is not null");

            return this;
        }

        public Criteria andStartDateIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.StartDate +
                " is not null AND " + IProductVersionStageDAO.StartDate +
                " <> ''");

            return this;
        }

        public Criteria andStartDateIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.StartDate +
                " is null OR " + IProductVersionStageDAO.StartDate + " = '')");

            return this;
        }

        public Criteria andStartDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate + " = ",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StartDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate + " <>",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                " is null OR " + IProductVersionStageDAO.StartDate + " <>",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StartDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate + " >",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StartDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate + " >=",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StartDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate + " <",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StartDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate + " <=",
                value, "startDate");

            return this;
        }

        public Criteria andStartDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.StartDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStartDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andStartDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                    " in", values, "startDate");

                return this;
            }
        }

        public Criteria andStartDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andStartDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                    " not in", values, "startDate");

                return this;
            }
        }

        public Criteria andStartDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andStartDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                    " in", Arrays.asList(values), "startDate");

                return this;
            }
        }

        public Criteria andStartDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andStartDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                    " not in", Arrays.asList(values), "startDate");

                return this;
            }
        }

        public Criteria andStartDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.StartDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStartDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                " between", value1, value2, "startDate");

            return this;
        }

        public Criteria andStartDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.StartDate +
                " not between", value1, value2, "startDate");

            return this;
        }

        public Criteria andEndDateIsNull() {
            addCriterion(IProductVersionStageDAO.EndDate + " is null");

            return this;
        }

        public Criteria andEndDateIsNotNull() {
            addCriterion(IProductVersionStageDAO.EndDate + " is not null");

            return this;
        }

        public Criteria andEndDateIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.EndDate + " is not null AND " +
                IProductVersionStageDAO.EndDate + " <> ''");

            return this;
        }

        public Criteria andEndDateIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.EndDate +
                " is null OR " + IProductVersionStageDAO.EndDate + " = '')");

            return this;
        }

        public Criteria andEndDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate + " = ",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.EndDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEndDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate + " <>",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                " is null OR " + IProductVersionStageDAO.EndDate + " <>",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.EndDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate + " >",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.EndDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate + " >=",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.EndDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate + " <",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.EndDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andEndDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate + " <=",
                value, "endDate");

            return this;
        }

        public Criteria andEndDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.EndDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andEndDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEndDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                    " in", values, "endDate");

                return this;
            }
        }

        public Criteria andEndDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andEndDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                    " not in", values, "endDate");

                return this;
            }
        }

        public Criteria andEndDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEndDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                    " in", Arrays.asList(values), "endDate");

                return this;
            }
        }

        public Criteria andEndDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andEndDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                    " not in", Arrays.asList(values), "endDate");

                return this;
            }
        }

        public Criteria andEndDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.EndDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andEndDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                " between", value1, value2, "endDate");

            return this;
        }

        public Criteria andEndDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.EndDate +
                " not between", value1, value2, "endDate");

            return this;
        }

        public Criteria andActualStartDateIsNull() {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " is null");

            return this;
        }

        public Criteria andActualStartDateIsNotNull() {
            addCriterion(IProductVersionStageDAO.ActualStartDate +
                " is not null");

            return this;
        }

        public Criteria andActualStartDateIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.ActualStartDate +
                " is not null AND " + IProductVersionStageDAO.ActualStartDate +
                " <> ''");

            return this;
        }

        public Criteria andActualStartDateIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.ActualStartDate +
                " is null OR " + IProductVersionStageDAO.ActualStartDate +
                " = '')");

            return this;
        }

        public Criteria andActualStartDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " = ", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualStartDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " <>", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateNotEqualToOrIsNull(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " is null OR " + IProductVersionStageDAO.ActualStartDate +
                " <>", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualStartDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " >", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualStartDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " >=", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualStartDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " <", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualStartDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateLessThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " <=", value, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualStartDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualStartDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualStartDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                    " in", values, "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualStartDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                    " not in", values, "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualStartDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                    " in", Arrays.asList(values), "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualStartDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                    " not in", Arrays.asList(values), "actualStartDate");

                return this;
            }
        }

        public Criteria andActualStartDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualStartDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualStartDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " between", value1, value2, "actualStartDate");

            return this;
        }

        public Criteria andActualStartDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualStartDate +
                " not between", value1, value2, "actualStartDate");

            return this;
        }

        public Criteria andActualEndDateIsNull() {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " is null");

            return this;
        }

        public Criteria andActualEndDateIsNotNull() {
            addCriterion(IProductVersionStageDAO.ActualEndDate +
                " is not null");

            return this;
        }

        public Criteria andActualEndDateIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.ActualEndDate +
                " is not null AND " + IProductVersionStageDAO.ActualEndDate +
                " <> ''");

            return this;
        }

        public Criteria andActualEndDateIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.ActualEndDate +
                " is null OR " + IProductVersionStageDAO.ActualEndDate +
                " = '')");

            return this;
        }

        public Criteria andActualEndDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " = ", value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualEndDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " <>", value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateNotEqualToOrIsNull(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " is null OR " + IProductVersionStageDAO.ActualEndDate + " <>",
                value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualEndDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateGreaterThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " >", value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualEndDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " >=", value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualEndDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " <", value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualEndDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateLessThanOrEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " <=", value, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ActualEndDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andActualEndDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualEndDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                    " in", values, "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateNotIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andActualEndDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                    " not in", values, "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualEndDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                    " in", Arrays.asList(values), "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andActualEndDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                    " not in", Arrays.asList(values), "actualEndDate");

                return this;
            }
        }

        public Criteria andActualEndDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ActualEndDate + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andActualEndDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " between", value1, value2, "actualEndDate");

            return this;
        }

        public Criteria andActualEndDateNotBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ActualEndDate +
                " not between", value1, value2, "actualEndDate");

            return this;
        }

        public Criteria andSortIndexIsNull() {
            addCriterion(IProductVersionStageDAO.SortIndex + " is null");

            return this;
        }

        public Criteria andSortIndexIsNotNull() {
            addCriterion(IProductVersionStageDAO.SortIndex + " is not null");

            return this;
        }

        public Criteria andSortIndexIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.SortIndex +
                " is not null AND " + IProductVersionStageDAO.SortIndex +
                " <> ''");

            return this;
        }

        public Criteria andSortIndexIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.SortIndex +
                " is null OR " + IProductVersionStageDAO.SortIndex + " = '')");

            return this;
        }

        public Criteria andSortIndexEqualTo(int value) {
            return andSortIndexEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexEqualTo(java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " = ", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.SortIndex);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexNotEqualTo(int value) {
            return andSortIndexNotEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexNotEqualTo(java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " <>", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotEqualToOrIsNull(int value) {
            return andSortIndexNotEqualToOrIsNull(Integer.valueOf(value));
        }

        public Criteria andSortIndexNotEqualToOrIsNull(java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " is null OR " +
                IProductVersionStageDAO.SortIndex + " <>", value, "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.SortIndex);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexGreaterThan(int value) {
            return andSortIndexGreaterThan(Integer.valueOf(value));
        }

        public Criteria andSortIndexGreaterThan(java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " >", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.SortIndex);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexGreaterThanOrEqualTo(int value) {
            return andSortIndexGreaterThanOrEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexGreaterThanOrEqualTo(
            java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " >=", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.SortIndex);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexLessThan(int value) {
            return andSortIndexLessThan(Integer.valueOf(value));
        }

        public Criteria andSortIndexLessThan(java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " <", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.SortIndex);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexLessThanOrEqualTo(int value) {
            return andSortIndexLessThanOrEqualTo(Integer.valueOf(value));
        }

        public Criteria andSortIndexLessThanOrEqualTo(java.lang.Integer value) {
            addCriterion(IProductVersionStageDAO.SortIndex + " <=", value,
                "sortIndex");

            return this;
        }

        public Criteria andSortIndexLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.SortIndex);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andSortIndexLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexIn(int[] values) {
            if (values.length == 1) {
                return andSortIndexEqualTo((java.lang.Integer) values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.SortIndex + " in", values,
                    "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexNotIn(int[] values) {
            if (values.length == 1) {
                return andSortIndexNotEqualTo((java.lang.Integer) values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.SortIndex + " not in",
                    values, "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexIn(List<java.lang.Integer> values) {
            if (values.size() == 1) {
                return andSortIndexEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.SortIndex + " in", values,
                    "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexNotIn(List<java.lang.Integer> values) {
            if (values.size() == 1) {
                return andSortIndexNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.SortIndex + " not in",
                    values, "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexIn(java.lang.Integer[] values) {
            if (values.length == 1) {
                return andSortIndexEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.SortIndex + " in",
                    Arrays.asList(values), "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexNotIn(java.lang.Integer[] values) {
            if (values.length == 1) {
                return andSortIndexNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.SortIndex + " not in",
                    Arrays.asList(values), "sortIndex");

                return this;
            }
        }

        public Criteria andSortIndexIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.SortIndex + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andSortIndexBetween(int value1, int value2) {
            addCriterion(IProductVersionStageDAO.SortIndex + " between",
                value1, value2, "sortIndex");

            return this;
        }

        public Criteria andSortIndexBetween(java.lang.Integer value1,
            java.lang.Integer value2) {
            addCriterion(IProductVersionStageDAO.SortIndex + " between",
                value1, value2, "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotBetween(int value1, int value2) {
            addCriterion(IProductVersionStageDAO.SortIndex + " not between",
                value1, value2, "sortIndex");

            return this;
        }

        public Criteria andSortIndexNotBetween(java.lang.Integer value1,
            java.lang.Integer value2) {
            addCriterion(IProductVersionStageDAO.SortIndex + " not between",
                value1, value2, "sortIndex");

            return this;
        }

        public Criteria andStatusIsNull() {
            addCriterion(IProductVersionStageDAO.Status + " is null");

            return this;
        }

        public Criteria andStatusIsNotNull() {
            addCriterion(IProductVersionStageDAO.Status + " is not null");

            return this;
        }

        public Criteria andStatusIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.Status + " is not null AND " +
                IProductVersionStageDAO.Status + " <> ''");

            return this;
        }

        public Criteria andStatusIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.Status + " is null OR " +
                IProductVersionStageDAO.Status + " = '')");

            return this;
        }

        public Criteria andStatusEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Status + " = ", value, "status");

            return this;
        }

        public Criteria andStatusEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Status);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusNotEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionStageDAO.Status + " is null OR " +
                IProductVersionStageDAO.Status + " <>", value, "status");

            return this;
        }

        public Criteria andStatusNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Status);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " <> ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusGreaterThan(String value) {
            addCriterion(IProductVersionStageDAO.Status + " >", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Status);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Status + " >=", value, "status");

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Status);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " >= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusLessThan(String value) {
            addCriterion(IProductVersionStageDAO.Status + " <", value, "status");

            return this;
        }

        public Criteria andStatusLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Status);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Status + " <=", value, "status");

            return this;
        }

        public Criteria andStatusLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Status);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andStatusLessThanOrEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " <= ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.Status + " like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.Status + " not like",
                buffer.toString(), "status");

            return this;
        }

        public Criteria andStatusIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.Status + " in", values,
                    "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(List<String> values) {
            if (values.size() == 1) {
                return andStatusNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.Status + " not in",
                    values, "status");

                return this;
            }
        }

        public Criteria andStatusIn(String[] values) {
            if (values.length == 1) {
                return andStatusEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Status + " in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusNotIn(String[] values) {
            if (values.length == 1) {
                return andStatusNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Status + " not in",
                    Arrays.asList(values), "status");

                return this;
            }
        }

        public Criteria andStatusIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " in ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andStatusNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Status + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andStatusBetween(String value1, String value2) {
            addCriterion(IProductVersionStageDAO.Status + " between", value1,
                value2, "status");

            return this;
        }

        public Criteria andStatusNotBetween(String value1, String value2) {
            addCriterion(IProductVersionStageDAO.Status + " not between",
                value1, value2, "status");

            return this;
        }

        public Criteria andRemarksIsNull() {
            addCriterion(IProductVersionStageDAO.Remarks + " is null");

            return this;
        }

        public Criteria andRemarksIsNotNull() {
            addCriterion(IProductVersionStageDAO.Remarks + " is not null");

            return this;
        }

        public Criteria andRemarksIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.Remarks + " is not null AND " +
                IProductVersionStageDAO.Remarks + " <> ''");

            return this;
        }

        public Criteria andRemarksIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.Remarks +
                " is null OR " + IProductVersionStageDAO.Remarks + " = '')");

            return this;
        }

        public Criteria andRemarksEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " = ", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Remarks);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " = ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksNotEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " <>", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " is null OR " +
                IProductVersionStageDAO.Remarks + " <>", value, "remarks");

            return this;
        }

        public Criteria andRemarksNotEqualToForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Remarks);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksNotEqualTo(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksGreaterThan(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " >", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Remarks);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " > ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " >=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Remarks);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLessThan(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " <", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanForeignKey(java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Remarks);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThan(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " < ", subQueryBean,
                dao);

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.Remarks + " <=", value,
                "remarks");

            return this;
        }

        public Criteria andRemarksLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.Remarks);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andRemarksLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.Remarks + " like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.Remarks + " not like",
                buffer.toString(), "remarks");

            return this;
        }

        public Criteria andRemarksIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.Remarks + " in", values,
                    "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(List<String> values) {
            if (values.size() == 1) {
                return andRemarksNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.Remarks + " not in",
                    values, "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(String[] values) {
            if (values.length == 1) {
                return andRemarksEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Remarks + " in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksNotIn(String[] values) {
            if (values.length == 1) {
                return andRemarksNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.Remarks + " not in",
                    Arrays.asList(values), "remarks");

                return this;
            }
        }

        public Criteria andRemarksIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.Remarks + " not in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andRemarksBetween(String value1, String value2) {
            addCriterion(IProductVersionStageDAO.Remarks + " between", value1,
                value2, "remarks");

            return this;
        }

        public Criteria andRemarksNotBetween(String value1, String value2) {
            addCriterion(IProductVersionStageDAO.Remarks + " not between",
                value1, value2, "remarks");

            return this;
        }

        public Criteria andProductVersionNameIsNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " is null");

            return this;
        }

        public Criteria andProductVersionNameIsNotNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " is not null");

            return this;
        }

        public Criteria andProductVersionNameIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " is not null AND " +
                IProductVersionStageDAO.ProductVersionName + " <> ''");

            return this;
        }

        public Criteria andProductVersionNameIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.ProductVersionName +
                " is null OR " + IProductVersionStageDAO.ProductVersionName +
                " = '')");

            return this;
        }

        public Criteria andProductVersionNameEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " = ",
                value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionName);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNameEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameNotEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " <>",
                value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameNotEqualToOrIsNull(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " is null OR " + IProductVersionStageDAO.ProductVersionName +
                " <>", value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionName);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNameNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " <> ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameGreaterThan(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " >",
                value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionName);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNameGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameGreaterThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " >=",
                value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionName);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNameGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " >= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameLessThan(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " <",
                value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionName);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNameLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameLessThanOrEqualTo(String value) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " <=",
                value, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionName);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionNameLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " <= ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.ProductVersionName + " like",
                buffer.toString(), "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameNotLike(String value) {
            StringBuffer buffer = new StringBuffer("%");
            buffer.append(value);
            buffer.append("%");
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " not like", buffer.toString(), "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameIn(List<String> values) {
            if (values.size() == 1) {
                return andProductVersionNameEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionName +
                    " in", values, "productVersionName");

                return this;
            }
        }

        public Criteria andProductVersionNameNotIn(List<String> values) {
            if (values.size() == 1) {
                return andProductVersionNameNotEqualTo(values.get(0));
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionName +
                    " not in", values, "productVersionName");

                return this;
            }
        }

        public Criteria andProductVersionNameIn(String[] values) {
            if (values.length == 1) {
                return andProductVersionNameEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionName +
                    " in", Arrays.asList(values), "productVersionName");

                return this;
            }
        }

        public Criteria andProductVersionNameNotIn(String[] values) {
            if (values.length == 1) {
                return andProductVersionNameNotEqualTo(values[0]);
            } else {
                addCriterion(IProductVersionStageDAO.ProductVersionName +
                    " not in", Arrays.asList(values), "productVersionName");

                return this;
            }
        }

        public Criteria andProductVersionNameIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName + " in ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameNotIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionNameBetween(String value1,
            String value2) {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " between", value1, value2, "productVersionName");

            return this;
        }

        public Criteria andProductVersionNameNotBetween(String value1,
            String value2) {
            addCriterion(IProductVersionStageDAO.ProductVersionName +
                " not between", value1, value2, "productVersionName");

            return this;
        }

        public Criteria andProductVersionStartDateIsNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " is null");

            return this;
        }

        public Criteria andProductVersionStartDateIsNotNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " is not null");

            return this;
        }

        public Criteria andProductVersionStartDateIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " is not null AND " +
                IProductVersionStageDAO.ProductVersionStartDate + " <> ''");

            return this;
        }

        public Criteria andProductVersionStartDateIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.ProductVersionStartDate +
                " is null OR " +
                IProductVersionStageDAO.ProductVersionStartDate + " = '')");

            return this;
        }

        public Criteria andProductVersionStartDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " = ", value, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionStartDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionStartDateEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " = ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateNotEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " <>", value, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateNotEqualToOrIsNull(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " is null OR " +
                IProductVersionStageDAO.ProductVersionStartDate + " <>", value,
                "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionStartDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionStartDateNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateGreaterThan(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " >", value, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionStartDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionStartDateGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " > ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " >=", value, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionStartDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionStartDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " <", value, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionStartDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionStartDateLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " < ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateLessThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " <=", value, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionStartDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionStartDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateIn(
            List<java.util.Date> values) {
            if (values.size() == 1) {
                return andProductVersionStartDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                    " in", values, "productVersionStartDate");

                return this;
            }
        }

        public Criteria andProductVersionStartDateNotIn(
            List<java.util.Date> values) {
            if (values.size() == 1) {
                return andProductVersionStartDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                    " not in", values, "productVersionStartDate");

                return this;
            }
        }

        public Criteria andProductVersionStartDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andProductVersionStartDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                    " in", Arrays.asList(values), "productVersionStartDate");

                return this;
            }
        }

        public Criteria andProductVersionStartDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andProductVersionStartDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                    " not in", Arrays.asList(values), "productVersionStartDate");

                return this;
            }
        }

        public Criteria andProductVersionStartDateIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionStartDate +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionStartDateBetween(
            java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " between", value1, value2, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionStartDateNotBetween(
            java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionStartDate +
                " not between", value1, value2, "productVersionStartDate");

            return this;
        }

        public Criteria andProductVersionEndDateIsNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " is null");

            return this;
        }

        public Criteria andProductVersionEndDateIsNotNull() {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " is not null");

            return this;
        }

        public Criteria andProductVersionEndDateIsNotEmpty() {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " is not null AND " +
                IProductVersionStageDAO.ProductVersionEndDate + " <> ''");

            return this;
        }

        public Criteria andProductVersionEndDateIsEmpty() {
            addCriterion("(" + IProductVersionStageDAO.ProductVersionEndDate +
                " is null OR " + IProductVersionStageDAO.ProductVersionEndDate +
                " = '')");

            return this;
        }

        public Criteria andProductVersionEndDateEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " = ", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionEndDate);
            str.append(" = ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEndDateEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate + " = ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateNotEqualTo(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " <>", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateNotEqualToOrIsNull(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " is null OR " + IProductVersionStageDAO.ProductVersionEndDate +
                " <>", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateNotEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionEndDate);
            str.append(" <> ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEndDateNotEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " <> ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateGreaterThan(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " >", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateGreaterThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionEndDate);
            str.append(" > ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEndDateGreaterThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate + " > ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateGreaterThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " >=", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateGreaterThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionEndDate);
            str.append(" >= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEndDateGreaterThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " >= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateLessThan(java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " <", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateLessThanForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionEndDate);
            str.append(" < ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEndDateLessThan(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate + " < ",
                subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateLessThanOrEqualTo(
            java.util.Date value) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " <=", value, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateLessThanOrEqualToForeignKey(
            java.lang.String key) {
            StringBuffer str = new StringBuffer(IProductVersionStageDAO.ProductVersionEndDate);
            str.append(" <= ").append(key);
            addForeignKeyCriterion(str.toString());

            return this;
        }

        public Criteria andProductVersionEndDateLessThanOrEqualTo(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " <= ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateIn(List<java.util.Date> values) {
            if (values.size() == 1) {
                return andProductVersionEndDateEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                    " in", values, "productVersionEndDate");

                return this;
            }
        }

        public Criteria andProductVersionEndDateNotIn(
            List<java.util.Date> values) {
            if (values.size() == 1) {
                return andProductVersionEndDateNotEqualTo(values.get(0));
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                    " not in", values, "productVersionEndDate");

                return this;
            }
        }

        public Criteria andProductVersionEndDateIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andProductVersionEndDateEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                    " in", Arrays.asList(values), "productVersionEndDate");

                return this;
            }
        }

        public Criteria andProductVersionEndDateNotIn(java.util.Date[] values) {
            if (values.length == 1) {
                return andProductVersionEndDateNotEqualTo(values[0]);
            } else {
                addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                    " not in", Arrays.asList(values), "productVersionEndDate");

                return this;
            }
        }

        public Criteria andProductVersionEndDateIn(BaseQueryBean subQueryBean,
            IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateNotIn(
            BaseQueryBean subQueryBean, IDataAccessInterface<?, ?> dao) {
            addCriterion(IProductVersionStageDAO.ProductVersionEndDate +
                " not in ", subQueryBean, dao);

            return this;
        }

        public Criteria andProductVersionEndDateBetween(java.util.Date value1,
            java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " between", value1, value2, "productVersionEndDate");

            return this;
        }

        public Criteria andProductVersionEndDateNotBetween(
            java.util.Date value1, java.util.Date value2) {
            addCriterionForJDBCDate(IProductVersionStageDAO.ProductVersionEndDate +
                " not between", value1, value2, "productVersionEndDate");

            return this;
        }
    }
}
